package java3.io;

public class Comepiezas extends B21Game {

    private static Loserchess loser;
    private static int contador;
    public static final int white = 0;
    public static final int black = 1;

    private static void init(int jugador) {
        loser = new Loserchess(jugador);
        System.out.println("-init loser-");
    }

    private static void destroy() {
        if (loser != null) {
            loser = null;
            System.out.println("-destroy loser-");
            contador = 0;
        }
    }

    public static void initGame(byte[] paramArrayOfByte) {

        int[][] tablero = B21Util.obtenerPosicion(2);

        B21Util.setPosiciones(tablero);
        B21Util.setEnroquecorto(true);
        B21Util.setEnroquelargo(true);
        B21Util.setEnroquecortoRival(true);
        B21Util.setEnroquelargoRival(true);
        esInicio = false;

        if (paramArrayOfByte[2] == 1) {
            esWhite = true;

            if (B21client.esRobot) {
                init(white);
                comenzarJuego(-1, -1);
                contador += 1;
            }
        } else {
            esWhite = false;
            if (B21client.esRobot) {
                esInicio = true;
                init(black);
            }
        }
    }

    private static void comenzarJuego(int ini, int fin) {
        try {
            boolean[] enroques = new boolean[]{B21Util.isEnroquecorto(),
                B21Util.isEnroquelargo(), B21Util.isEnroquecortoRival(), B21Util.isEnroquelargoRival()};
            int[] jug = loser.jugar(B21Util.obtenerPosicion(-1), ini, fin, enroques);
            if (B21client.esRobot && jug != null) {
                RobotChess.realizarJugadaLoser(jug, B21Game.esWhite, true);//xx,yy
            }
        } catch (Exception localException) {
            System.out.println("error-comenzarJuego: " + localException);
            localException.printStackTrace();
            int[][] arrayOfInt = B21Util.obtenerPosicion(-1);
            for (int i = 0; i < 2; i++) {
                for (int j = 0; j < 64; j++) {
                    System.out.println("pos[" + i + "][" + j + "]=" + arrayOfInt[i][j] + ";");
                }
            }
        }
    }

    public static void playGame(byte[] jugada_rival) {

        if (B21Util.isEnroquecortoRival() || B21Util.isEnroquelargoRival()) {
            int ficha = B21Util.obtenerPosicion(-1)[0][jugada_rival[0]];

            if (ficha == 6) {
                B21Util.setEnroquecortoRival(false);
                B21Util.setEnroquelargoRival(false);
            } else if (ficha == 4) {
                switch (jugada_rival[0]) {
                    case 0:
                    case 56:
                        B21Util.setEnroquelargoRival(false);
                        break;
                    case 7:
                    case 63:
                        B21Util.setEnroquecortoRival(false);
                        break;
                }
            } 
        } 
        
        if (B21Util.isEnroquecorto() || B21Util.isEnroquelargo()) {
            if (B21Util.obtenerPosicion(-1)[0][jugada_rival[1]] == 4) {
                switch (jugada_rival[1]) {
                    case 0:
                    case 56:
                        B21Util.setEnroquelargo(false);
                        break;
                    case 7:
                    case 63:
                        B21Util.setEnroquecorto(false);
                        break;
                }
            }
        }
        
        B21Util.ingresarJugada(jugada_rival[0], jugada_rival[1], jugada_rival[2]);

        if (!jugadaIlegal) {
            if (B21client.esRobot) {
                System.out.println("rival: " + B21Util.pos1(jugada_rival[0]) + B21Util.pos1(jugada_rival[1]));
                if (esInicio) {
                    esInicio = false;
                    comenzarJuego(jugada_rival[0], jugada_rival[1]);
                    contador += 1;
                } else {
                    if (contador == 0) {
                        init(esWhite ? white : black);
                        if (esWhite) {
                            comenzarJuego(-1, -1);
                        } else {
                            comenzarJuego(jugada_rival[0], jugada_rival[1]);
                        }
                        contador += 1;
                    } else {
                        continuarJuego(jugada_rival[0], jugada_rival[1]);
                    }
                }
            } else {
                destroy();
            }
        } else {
            destroy();
            B21client.esRobot = false;
            contador = 0;
        }
    }

    private static void continuarJuego(int ini, int fin) {
        try {
            boolean[] enroques = new boolean[]{B21Util.isEnroquecorto(),
                B21Util.isEnroquelargo(), B21Util.isEnroquecortoRival(), B21Util.isEnroquelargoRival()};
            int[] jugada = loser.jugar(B21Util.obtenerPosicion(-1), ini, fin, enroques);
            if (B21client.esRobot && jugada != null) {
                RobotChess.realizarJugadaLoser(jugada, B21Game.esWhite, true);//xx,yy
            }
        } catch (Exception localException) {
            System.out.println("error-continuarJuego: " + localException);
            localException.printStackTrace();
        }
    }

    public static void finishGame() {
        if (loser != null) {
            destroy();
            System.out.println("**finish game loser");
        }
    }
}
